/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package gmovil_jpa.controladores;

import gmovil_jpa.controladores.exceptions.IllegalOrphanException;
import gmovil_jpa.controladores.exceptions.NonexistentEntityException;
import gmovil_jpa.entidades.Persona;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import gmovil_jpa.entidades.TipoPersona;
import gmovil_jpa.entidades.TipoSociedad;
import gmovil_jpa.entidades.TipoEstadoCivil;
import gmovil_jpa.entidades.TipoCuentaBancaria;
import gmovil_jpa.entidades.Banco;
import gmovil_jpa.entidades.TipoDocumentoIdentidad;
import gmovil_jpa.entidades.Cliente;
import java.util.ArrayList;
import java.util.List;
import gmovil_jpa.entidades.Proveedor;
import gmovil_jpa.entidades.Empleado;

/**
 *
 * @author castlerock
 */
public class PersonaJpaController {

    public PersonaJpaController() {
        emf = Persistence.createEntityManagerFactory("gmovil_jpaPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Persona persona) {
        if (persona.getClienteList() == null) {
            persona.setClienteList(new ArrayList<Cliente>());
        }
        if (persona.getProveedorList() == null) {
            persona.setProveedorList(new ArrayList<Proveedor>());
        }
        if (persona.getEmpleadoList() == null) {
            persona.setEmpleadoList(new ArrayList<Empleado>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            TipoPersona tipoPersona = persona.getTipoPersona();
            if (tipoPersona != null) {
                tipoPersona = em.getReference(tipoPersona.getClass(), tipoPersona.getIdTipoPersona());
                persona.setTipoPersona(tipoPersona);
            }
            TipoSociedad tipoSociedad = persona.getTipoSociedad();
            if (tipoSociedad != null) {
                tipoSociedad = em.getReference(tipoSociedad.getClass(), tipoSociedad.getIdTipoSociedad());
                persona.setTipoSociedad(tipoSociedad);
            }
            TipoEstadoCivil tipoEstadoCivil = persona.getTipoEstadoCivil();
            if (tipoEstadoCivil != null) {
                tipoEstadoCivil = em.getReference(tipoEstadoCivil.getClass(), tipoEstadoCivil.getIdTipoEstadoCivil());
                persona.setTipoEstadoCivil(tipoEstadoCivil);
            }
            TipoCuentaBancaria tipoCuentaBancaria = persona.getTipoCuentaBancaria();
            if (tipoCuentaBancaria != null) {
                tipoCuentaBancaria = em.getReference(tipoCuentaBancaria.getClass(), tipoCuentaBancaria.getIdTipoCuentaBancaria());
                persona.setTipoCuentaBancaria(tipoCuentaBancaria);
            }
            Banco banco = persona.getBanco();
            if (banco != null) {
                banco = em.getReference(banco.getClass(), banco.getIdBanco());
                persona.setBanco(banco);
            }
            TipoDocumentoIdentidad tipoDocumentoIdentidad = persona.getTipoDocumentoIdentidad();
            if (tipoDocumentoIdentidad != null) {
                tipoDocumentoIdentidad = em.getReference(tipoDocumentoIdentidad.getClass(), tipoDocumentoIdentidad.getIdTipoDocumentoIdentidad());
                persona.setTipoDocumentoIdentidad(tipoDocumentoIdentidad);
            }
            List<Cliente> attachedClienteList = new ArrayList<Cliente>();
            for (Cliente clienteListClienteToAttach : persona.getClienteList()) {
                clienteListClienteToAttach = em.getReference(clienteListClienteToAttach.getClass(), clienteListClienteToAttach.getIdCliente());
                attachedClienteList.add(clienteListClienteToAttach);
            }
            persona.setClienteList(attachedClienteList);
            List<Proveedor> attachedProveedorList = new ArrayList<Proveedor>();
            for (Proveedor proveedorListProveedorToAttach : persona.getProveedorList()) {
                proveedorListProveedorToAttach = em.getReference(proveedorListProveedorToAttach.getClass(), proveedorListProveedorToAttach.getIdProveedor());
                attachedProveedorList.add(proveedorListProveedorToAttach);
            }
            persona.setProveedorList(attachedProveedorList);
            List<Empleado> attachedEmpleadoList = new ArrayList<Empleado>();
            for (Empleado empleadoListEmpleadoToAttach : persona.getEmpleadoList()) {
                empleadoListEmpleadoToAttach = em.getReference(empleadoListEmpleadoToAttach.getClass(), empleadoListEmpleadoToAttach.getIdEmpleado());
                attachedEmpleadoList.add(empleadoListEmpleadoToAttach);
            }
            persona.setEmpleadoList(attachedEmpleadoList);
            em.persist(persona);
            if (tipoPersona != null) {
                tipoPersona.getPersonaList().add(persona);
                tipoPersona = em.merge(tipoPersona);
            }
            if (tipoSociedad != null) {
                tipoSociedad.getPersonaList().add(persona);
                tipoSociedad = em.merge(tipoSociedad);
            }
            if (tipoEstadoCivil != null) {
                tipoEstadoCivil.getPersonaList().add(persona);
                tipoEstadoCivil = em.merge(tipoEstadoCivil);
            }
            if (tipoCuentaBancaria != null) {
                tipoCuentaBancaria.getPersonaList().add(persona);
                tipoCuentaBancaria = em.merge(tipoCuentaBancaria);
            }
            if (banco != null) {
                banco.getPersonaList().add(persona);
                banco = em.merge(banco);
            }
            if (tipoDocumentoIdentidad != null) {
                tipoDocumentoIdentidad.getPersonaList().add(persona);
                tipoDocumentoIdentidad = em.merge(tipoDocumentoIdentidad);
            }
            for (Cliente clienteListCliente : persona.getClienteList()) {
                Persona oldPersonaOfClienteListCliente = clienteListCliente.getPersona();
                clienteListCliente.setPersona(persona);
                clienteListCliente = em.merge(clienteListCliente);
                if (oldPersonaOfClienteListCliente != null) {
                    oldPersonaOfClienteListCliente.getClienteList().remove(clienteListCliente);
                    oldPersonaOfClienteListCliente = em.merge(oldPersonaOfClienteListCliente);
                }
            }
            for (Proveedor proveedorListProveedor : persona.getProveedorList()) {
                Persona oldPersonaOfProveedorListProveedor = proveedorListProveedor.getPersona();
                proveedorListProveedor.setPersona(persona);
                proveedorListProveedor = em.merge(proveedorListProveedor);
                if (oldPersonaOfProveedorListProveedor != null) {
                    oldPersonaOfProveedorListProveedor.getProveedorList().remove(proveedorListProveedor);
                    oldPersonaOfProveedorListProveedor = em.merge(oldPersonaOfProveedorListProveedor);
                }
            }
            for (Empleado empleadoListEmpleado : persona.getEmpleadoList()) {
                Persona oldPersonaOfEmpleadoListEmpleado = empleadoListEmpleado.getPersona();
                empleadoListEmpleado.setPersona(persona);
                empleadoListEmpleado = em.merge(empleadoListEmpleado);
                if (oldPersonaOfEmpleadoListEmpleado != null) {
                    oldPersonaOfEmpleadoListEmpleado.getEmpleadoList().remove(empleadoListEmpleado);
                    oldPersonaOfEmpleadoListEmpleado = em.merge(oldPersonaOfEmpleadoListEmpleado);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Persona persona) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Persona persistentPersona = em.find(Persona.class, persona.getIdPersona());
            TipoPersona tipoPersonaOld = persistentPersona.getTipoPersona();
            TipoPersona tipoPersonaNew = persona.getTipoPersona();
            TipoSociedad tipoSociedadOld = persistentPersona.getTipoSociedad();
            TipoSociedad tipoSociedadNew = persona.getTipoSociedad();
            TipoEstadoCivil tipoEstadoCivilOld = persistentPersona.getTipoEstadoCivil();
            TipoEstadoCivil tipoEstadoCivilNew = persona.getTipoEstadoCivil();
            TipoCuentaBancaria tipoCuentaBancariaOld = persistentPersona.getTipoCuentaBancaria();
            TipoCuentaBancaria tipoCuentaBancariaNew = persona.getTipoCuentaBancaria();
            Banco bancoOld = persistentPersona.getBanco();
            Banco bancoNew = persona.getBanco();
            TipoDocumentoIdentidad tipoDocumentoIdentidadOld = persistentPersona.getTipoDocumentoIdentidad();
            TipoDocumentoIdentidad tipoDocumentoIdentidadNew = persona.getTipoDocumentoIdentidad();
            List<Cliente> clienteListOld = persistentPersona.getClienteList();
            List<Cliente> clienteListNew = persona.getClienteList();
            List<Proveedor> proveedorListOld = persistentPersona.getProveedorList();
            List<Proveedor> proveedorListNew = persona.getProveedorList();
            List<Empleado> empleadoListOld = persistentPersona.getEmpleadoList();
            List<Empleado> empleadoListNew = persona.getEmpleadoList();
            List<String> illegalOrphanMessages = null;
            for (Cliente clienteListOldCliente : clienteListOld) {
                if (!clienteListNew.contains(clienteListOldCliente)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Cliente " + clienteListOldCliente + " since its persona field is not nullable.");
                }
            }
            for (Proveedor proveedorListOldProveedor : proveedorListOld) {
                if (!proveedorListNew.contains(proveedorListOldProveedor)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Proveedor " + proveedorListOldProveedor + " since its persona field is not nullable.");
                }
            }
            for (Empleado empleadoListOldEmpleado : empleadoListOld) {
                if (!empleadoListNew.contains(empleadoListOldEmpleado)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Empleado " + empleadoListOldEmpleado + " since its persona field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (tipoPersonaNew != null) {
                tipoPersonaNew = em.getReference(tipoPersonaNew.getClass(), tipoPersonaNew.getIdTipoPersona());
                persona.setTipoPersona(tipoPersonaNew);
            }
            if (tipoSociedadNew != null) {
                tipoSociedadNew = em.getReference(tipoSociedadNew.getClass(), tipoSociedadNew.getIdTipoSociedad());
                persona.setTipoSociedad(tipoSociedadNew);
            }
            if (tipoEstadoCivilNew != null) {
                tipoEstadoCivilNew = em.getReference(tipoEstadoCivilNew.getClass(), tipoEstadoCivilNew.getIdTipoEstadoCivil());
                persona.setTipoEstadoCivil(tipoEstadoCivilNew);
            }
            if (tipoCuentaBancariaNew != null) {
                tipoCuentaBancariaNew = em.getReference(tipoCuentaBancariaNew.getClass(), tipoCuentaBancariaNew.getIdTipoCuentaBancaria());
                persona.setTipoCuentaBancaria(tipoCuentaBancariaNew);
            }
            if (bancoNew != null) {
                bancoNew = em.getReference(bancoNew.getClass(), bancoNew.getIdBanco());
                persona.setBanco(bancoNew);
            }
            if (tipoDocumentoIdentidadNew != null) {
                tipoDocumentoIdentidadNew = em.getReference(tipoDocumentoIdentidadNew.getClass(), tipoDocumentoIdentidadNew.getIdTipoDocumentoIdentidad());
                persona.setTipoDocumentoIdentidad(tipoDocumentoIdentidadNew);
            }
            List<Cliente> attachedClienteListNew = new ArrayList<Cliente>();
            for (Cliente clienteListNewClienteToAttach : clienteListNew) {
                clienteListNewClienteToAttach = em.getReference(clienteListNewClienteToAttach.getClass(), clienteListNewClienteToAttach.getIdCliente());
                attachedClienteListNew.add(clienteListNewClienteToAttach);
            }
            clienteListNew = attachedClienteListNew;
            persona.setClienteList(clienteListNew);
            List<Proveedor> attachedProveedorListNew = new ArrayList<Proveedor>();
            for (Proveedor proveedorListNewProveedorToAttach : proveedorListNew) {
                proveedorListNewProveedorToAttach = em.getReference(proveedorListNewProveedorToAttach.getClass(), proveedorListNewProveedorToAttach.getIdProveedor());
                attachedProveedorListNew.add(proveedorListNewProveedorToAttach);
            }
            proveedorListNew = attachedProveedorListNew;
            persona.setProveedorList(proveedorListNew);
            List<Empleado> attachedEmpleadoListNew = new ArrayList<Empleado>();
            for (Empleado empleadoListNewEmpleadoToAttach : empleadoListNew) {
                empleadoListNewEmpleadoToAttach = em.getReference(empleadoListNewEmpleadoToAttach.getClass(), empleadoListNewEmpleadoToAttach.getIdEmpleado());
                attachedEmpleadoListNew.add(empleadoListNewEmpleadoToAttach);
            }
            empleadoListNew = attachedEmpleadoListNew;
            persona.setEmpleadoList(empleadoListNew);
            persona = em.merge(persona);
            if (tipoPersonaOld != null && !tipoPersonaOld.equals(tipoPersonaNew)) {
                tipoPersonaOld.getPersonaList().remove(persona);
                tipoPersonaOld = em.merge(tipoPersonaOld);
            }
            if (tipoPersonaNew != null && !tipoPersonaNew.equals(tipoPersonaOld)) {
                tipoPersonaNew.getPersonaList().add(persona);
                tipoPersonaNew = em.merge(tipoPersonaNew);
            }
            if (tipoSociedadOld != null && !tipoSociedadOld.equals(tipoSociedadNew)) {
                tipoSociedadOld.getPersonaList().remove(persona);
                tipoSociedadOld = em.merge(tipoSociedadOld);
            }
            if (tipoSociedadNew != null && !tipoSociedadNew.equals(tipoSociedadOld)) {
                tipoSociedadNew.getPersonaList().add(persona);
                tipoSociedadNew = em.merge(tipoSociedadNew);
            }
            if (tipoEstadoCivilOld != null && !tipoEstadoCivilOld.equals(tipoEstadoCivilNew)) {
                tipoEstadoCivilOld.getPersonaList().remove(persona);
                tipoEstadoCivilOld = em.merge(tipoEstadoCivilOld);
            }
            if (tipoEstadoCivilNew != null && !tipoEstadoCivilNew.equals(tipoEstadoCivilOld)) {
                tipoEstadoCivilNew.getPersonaList().add(persona);
                tipoEstadoCivilNew = em.merge(tipoEstadoCivilNew);
            }
            if (tipoCuentaBancariaOld != null && !tipoCuentaBancariaOld.equals(tipoCuentaBancariaNew)) {
                tipoCuentaBancariaOld.getPersonaList().remove(persona);
                tipoCuentaBancariaOld = em.merge(tipoCuentaBancariaOld);
            }
            if (tipoCuentaBancariaNew != null && !tipoCuentaBancariaNew.equals(tipoCuentaBancariaOld)) {
                tipoCuentaBancariaNew.getPersonaList().add(persona);
                tipoCuentaBancariaNew = em.merge(tipoCuentaBancariaNew);
            }
            if (bancoOld != null && !bancoOld.equals(bancoNew)) {
                bancoOld.getPersonaList().remove(persona);
                bancoOld = em.merge(bancoOld);
            }
            if (bancoNew != null && !bancoNew.equals(bancoOld)) {
                bancoNew.getPersonaList().add(persona);
                bancoNew = em.merge(bancoNew);
            }
            if (tipoDocumentoIdentidadOld != null && !tipoDocumentoIdentidadOld.equals(tipoDocumentoIdentidadNew)) {
                tipoDocumentoIdentidadOld.getPersonaList().remove(persona);
                tipoDocumentoIdentidadOld = em.merge(tipoDocumentoIdentidadOld);
            }
            if (tipoDocumentoIdentidadNew != null && !tipoDocumentoIdentidadNew.equals(tipoDocumentoIdentidadOld)) {
                tipoDocumentoIdentidadNew.getPersonaList().add(persona);
                tipoDocumentoIdentidadNew = em.merge(tipoDocumentoIdentidadNew);
            }
            for (Cliente clienteListNewCliente : clienteListNew) {
                if (!clienteListOld.contains(clienteListNewCliente)) {
                    Persona oldPersonaOfClienteListNewCliente = clienteListNewCliente.getPersona();
                    clienteListNewCliente.setPersona(persona);
                    clienteListNewCliente = em.merge(clienteListNewCliente);
                    if (oldPersonaOfClienteListNewCliente != null && !oldPersonaOfClienteListNewCliente.equals(persona)) {
                        oldPersonaOfClienteListNewCliente.getClienteList().remove(clienteListNewCliente);
                        oldPersonaOfClienteListNewCliente = em.merge(oldPersonaOfClienteListNewCliente);
                    }
                }
            }
            for (Proveedor proveedorListNewProveedor : proveedorListNew) {
                if (!proveedorListOld.contains(proveedorListNewProveedor)) {
                    Persona oldPersonaOfProveedorListNewProveedor = proveedorListNewProveedor.getPersona();
                    proveedorListNewProveedor.setPersona(persona);
                    proveedorListNewProveedor = em.merge(proveedorListNewProveedor);
                    if (oldPersonaOfProveedorListNewProveedor != null && !oldPersonaOfProveedorListNewProveedor.equals(persona)) {
                        oldPersonaOfProveedorListNewProveedor.getProveedorList().remove(proveedorListNewProveedor);
                        oldPersonaOfProveedorListNewProveedor = em.merge(oldPersonaOfProveedorListNewProveedor);
                    }
                }
            }
            for (Empleado empleadoListNewEmpleado : empleadoListNew) {
                if (!empleadoListOld.contains(empleadoListNewEmpleado)) {
                    Persona oldPersonaOfEmpleadoListNewEmpleado = empleadoListNewEmpleado.getPersona();
                    empleadoListNewEmpleado.setPersona(persona);
                    empleadoListNewEmpleado = em.merge(empleadoListNewEmpleado);
                    if (oldPersonaOfEmpleadoListNewEmpleado != null && !oldPersonaOfEmpleadoListNewEmpleado.equals(persona)) {
                        oldPersonaOfEmpleadoListNewEmpleado.getEmpleadoList().remove(empleadoListNewEmpleado);
                        oldPersonaOfEmpleadoListNewEmpleado = em.merge(oldPersonaOfEmpleadoListNewEmpleado);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = persona.getIdPersona();
                if (findPersona(id) == null) {
                    throw new NonexistentEntityException("The persona with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Persona persona;
            try {
                persona = em.getReference(Persona.class, id);
                persona.getIdPersona();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The persona with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Cliente> clienteListOrphanCheck = persona.getClienteList();
            for (Cliente clienteListOrphanCheckCliente : clienteListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Persona (" + persona + ") cannot be destroyed since the Cliente " + clienteListOrphanCheckCliente + " in its clienteList field has a non-nullable persona field.");
            }
            List<Proveedor> proveedorListOrphanCheck = persona.getProveedorList();
            for (Proveedor proveedorListOrphanCheckProveedor : proveedorListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Persona (" + persona + ") cannot be destroyed since the Proveedor " + proveedorListOrphanCheckProveedor + " in its proveedorList field has a non-nullable persona field.");
            }
            List<Empleado> empleadoListOrphanCheck = persona.getEmpleadoList();
            for (Empleado empleadoListOrphanCheckEmpleado : empleadoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Persona (" + persona + ") cannot be destroyed since the Empleado " + empleadoListOrphanCheckEmpleado + " in its empleadoList field has a non-nullable persona field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            TipoPersona tipoPersona = persona.getTipoPersona();
            if (tipoPersona != null) {
                tipoPersona.getPersonaList().remove(persona);
                tipoPersona = em.merge(tipoPersona);
            }
            TipoSociedad tipoSociedad = persona.getTipoSociedad();
            if (tipoSociedad != null) {
                tipoSociedad.getPersonaList().remove(persona);
                tipoSociedad = em.merge(tipoSociedad);
            }
            TipoEstadoCivil tipoEstadoCivil = persona.getTipoEstadoCivil();
            if (tipoEstadoCivil != null) {
                tipoEstadoCivil.getPersonaList().remove(persona);
                tipoEstadoCivil = em.merge(tipoEstadoCivil);
            }
            TipoCuentaBancaria tipoCuentaBancaria = persona.getTipoCuentaBancaria();
            if (tipoCuentaBancaria != null) {
                tipoCuentaBancaria.getPersonaList().remove(persona);
                tipoCuentaBancaria = em.merge(tipoCuentaBancaria);
            }
            Banco banco = persona.getBanco();
            if (banco != null) {
                banco.getPersonaList().remove(persona);
                banco = em.merge(banco);
            }
            TipoDocumentoIdentidad tipoDocumentoIdentidad = persona.getTipoDocumentoIdentidad();
            if (tipoDocumentoIdentidad != null) {
                tipoDocumentoIdentidad.getPersonaList().remove(persona);
                tipoDocumentoIdentidad = em.merge(tipoDocumentoIdentidad);
            }
            em.remove(persona);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Persona> findPersonaEntities() {
        return findPersonaEntities(true, -1, -1);
    }

    public List<Persona> findPersonaEntities(int maxResults, int firstResult) {
        return findPersonaEntities(false, maxResults, firstResult);
    }

    private List<Persona> findPersonaEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Persona.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Persona findPersona(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Persona.class, id);
        } finally {
            em.close();
        }
    }

    public int getPersonaCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Persona> rt = cq.from(Persona.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
